import { request, initBaseUrl, getFullImageUrl } from '@/utils/request';
export default {
    props: {
        show: {
            type: Boolean,
            default: false
        },
        order: {
            type: Object,
            default: () => ({})
        },
        // 用于样式调试的模拟数据
        mockData: {
            type: Array,
            default: () => []
        }
    },
    data() {
        return {
            candidates: [], // 候选人列表
            selected_total: 0,//待选择人数
            total: 0, // 总人数
            currentIndex: 0, // 当前显示的候选人索引
            page: 1, // 当前页码
            limit: 10, // 每页数量
            selectedCount: 0, // 已选择人数
            batchSize: 10, // 每批显示人数
            currentBatch: 1, // 当前批次
            totalBatches: 1, // 总批次数
            countdownTime: '', // 倒计时显示
            countdownTimer: null, // 倒计时定时器
            recruitmentDeadline: null, // 招募截止时间
            isRecruitmentExpired: false // 招募是否已过期
        }
    },
    computed: {
        // 当前显示的候选人
        currentCandidate() {
            console.log("候选人：",this.candidates[this.currentIndex])
            return this.candidates[this.currentIndex] || {};
        },
        // 批次信息显示
        batchInfo() {
            return `${this.currentBatch}/${this.totalBatches}`;
        }
    },
    mounted() {
        
        console.log('组件已挂载，当前show值:', this.show);
        // 手动触发一次数据加载
        if (this.show) {
            this.fetchCandidates();
        }
    },
    watch: {
        show: {
            handler(newVal, oldVal) {
                console.log('show值变化:', '旧值:', oldVal, '新值:', newVal);
                if (newVal) {
                    this.fetchCandidates();
                    this.startCountdown();
                } else {
                    this.stopCountdown();
                }
            },
            immediate: true, // 立即执行一次
            deep: false
        }
    },
    methods: {
        getFullImageUrl,
        // 清理媒体URL中的空格和反引号
        formatMediaUrl(url) {
            if (!url) return '';
            // 移除前后的空格和反引号
            let cleanUrl = url.trim().replace(/^`|`$/g, '');
            return cleanUrl;
        },
        // 格式化视频时长
        formatVideoDuration(duration) {
            if (!duration) return '';
            const minutes = Math.floor(duration / 60);
            const seconds = Math.floor(duration % 60);
            return `${minutes}:${seconds.toString().padStart(2, '0')}`;
        },
        // 获取候选人列表
        async fetchCandidates() {
            console.log('fetchCandidates方法被调用，参数:');
            console.log('page:', this.page);
            console.log('limit:', this.batchSize);
            console.log('job_id:', this.order.task_id);
            console.log('uni对象是否存在:', typeof uni !== 'undefined');
            
            // 如果提供了mockData，则使用模拟数据
            if (this.mockData && this.mockData.length > 0) {
                console.log('使用模拟数据进行调试');
                this.candidates = this.mockData;
                this.total = this.mockData.length;
                this.selected_total = 2; // 模拟待选择人数
                this.totalBatches = Math.ceil(this.total / this.batchSize);
                this.selectedCount = this.candidates.filter(item => item.selected).length;
                return;
            }
            
            try {
                const response = await request({
                    url: '/WorkerPosts/getcandidates', // 假设的接口地址
                    method: 'GET',
                    data: {
                        page: this.page,
                        limit: this.batchSize, // 使用批次大小作为每页数量
                        job_id: this.order.task_id
                    }
                });
                console.log('接口响应:', response);
                
                if (response.code === 200) {
                    this.candidates = response.data;
                    this.total = response.total;
                    this.page = response.page;
                    this.limit = this.batchSize;
                    this.selected_total = response.selected_total;
                    // 计算总批次数
                    this.totalBatches = Math.ceil(this.total / this.batchSize);
                    // 计算已选择人数
                    this.selectedCount = this.candidates.filter(item => item.selected).length;
                    console.log('数据更新成功，candidates.length=' + this.candidates.length);
                } else {
                    console.error('接口返回错误:', response.msg);
                    uni.showToast({
                        title: response.msg || '获取候选人失败',
                        icon: 'none'
                    });
                }
            } catch (error) {
                console.error('获取候选人列表失败:', error);
                // 简化showToast调用
                if (typeof uni !== 'undefined' && uni.showToast) {
                    uni.showToast({
                        title: '网络错误，请重试',
                        icon: 'none',
                        duration: 2000
                    });
                } else {
                    console.error('uni.showToast 不可用');
                }
                throw error; // 重新抛出错误，让调用者捕获
            }
        },
        
        // 关闭模态框
        closeModal() {
            this.$emit('close');
        },
        
        // 取消招募
        cancelRecruit() {
            uni.showModal({
                title: '提示',
                content: '确定要取消招募吗？',
                success: (res) => {
                    if (res.confirm) {
                        // 调用取消招募接口
                        this.cancelRecruitApi();
                    }
                }
            });
        },
        
        // 继续招募
        continueRecruit() {
            uni.showModal({
                title: '继续招募',
                content: '确定要继续招募吗？这将保持任务状态为招募中。',
                success: (res) => {
                    if (res.confirm) {
                        this.closeModal();
                    }
                }
            });
        },
        
        // 取消任务
        cancelTask() {
            uni.showModal({
                title: '取消任务',
                content: '确定要取消任务吗？这将取消所有已选择的订单。',
                success: (res) => {
                    if (res.confirm) {
                        this.cancelTaskApi();
                    }
                }
            });
        },
        
        // 调用取消招募接口
        async cancelRecruitApi() {
            try {
                const response = await request({
                    url: '/WorkerPosts/cancelRecruitment',
                    method: 'POST',
                    data: {
                        job_id: this.order.task_id
                    }
                });
                
                if (response.code === 200) {
                    uni.showToast({
                        title: '已取消招募',
                        icon: 'success'
                    });
                    this.closeModal();
                } else {
                    uni.showToast({
                        title: response.msg || '取消招募失败',
                        icon: 'none'
                    });
                }
            } catch (error) {
                console.error('取消招募失败:', error);
                uni.showToast({
                    title: '网络错误，请重试',
                    icon: 'none'
                });
            }
        },
        
        // 调用取消任务接口
        async cancelTaskApi() {
            try {
                const response = await request({
                    url: '/WorkerPosts/cancelTask',
                    method: 'POST',
                    data: {
                        job_id: this.order.task_id
                    }
                });
                
                if (response.code === 200) {
                    uni.showToast({
                        title: '已取消任务',
                        icon: 'success'
                    });
                    this.closeModal();
                    // 通知父组件刷新订单列表
                    this.$emit('taskCancelled');
                } else {
                    uni.showToast({
                        title: response.msg || '取消任务失败',
                        icon: 'none'
                    });
                }
            } catch (error) {
                console.error('取消任务失败:', error);
                uni.showToast({
                    title: '网络错误，请重试',
                    icon: 'none'
                });
            }
        },
        
        // 切换到上一个候选人
        prevOne() {
            console.log('prevOne方法被调用');
            if (this.currentIndex > 0) {
                this.currentIndex--;
            } else if (this.currentBatch > 1) {
                // 如果是当前批次的第一个，且不是第一批，则加载上一批
                this.currentBatch--;
                this.page = this.currentBatch;
                try {
                    this.fetchCandidates();
                    // 加载上一批后，显示最后一个候选人
                    this.$nextTick(() => {
                        this.currentIndex = this.candidates.length - 1;
                    });
                } catch (error) {
                    console.error('加载上一批候选人失败:', error);
                    this.currentBatch++;
                    this.page = this.currentBatch;
                }
            } else {
                // 如果是第一批的第一个，则提示已是第一个
                uni.showToast({
                    title: '已是第一个',
                    icon: 'none'
                });
            }
        },
        
        // 切换到下一个候选人
        async nextOne() {
            console.log('nextOne方法被调用');
            
            // 先检查是否不是当前批次的最后一个
            if (this.currentIndex < this.candidates.length - 1) {
                this.currentIndex++;
            } else if (this.currentBatch < this.totalBatches) {
                // 如果是当前批次的最后一个，且不是最后一批，则加载下一批
                this.currentBatch++;
                this.page = this.currentBatch;
                try {
                    await this.fetchCandidates();
                    this.currentIndex = 0;
                } catch (error) {
                    console.error('加载下一批候选人失败:', error);
                    this.currentBatch--;
                    this.page = this.currentBatch;
                }
            } else {
                // 如果是最后一批的最后一个，则尝试换一批
                const originalCandidates = [...this.candidates];
                const originalIndex = this.currentIndex;
                
                try {
                    await this.changeBatch();
                    
                    // 检查换一批后是否有新的候选人
                    if (this.candidates.length > 0 && 
                        (this.candidates.length !== originalCandidates.length || 
                         JSON.stringify(this.candidates) !== JSON.stringify(originalCandidates))) {
                        // 有新的候选人，跳到新的候选人位置（当前索引+1）
                        // 如果当前索引+1超出了新列表的长度，则设置为最后一个
                        this.currentIndex++;
                        if (this.currentIndex >= this.candidates.length) {
                            this.currentIndex = this.candidates.length - 1;
                        }
                    } else {
                        // 没有新的候选人，保留在最后一个候选人
                        if (this.candidates.length > 0) {
                            this.currentIndex = this.candidates.length - 1;
                        }
                        uni.showToast({
                            title: '已是最后一个',
                            icon: 'none'
                        });
                    }
                } catch (error) {
                    console.error('换一批失败:', error);
                    uni.showToast({
                        title: '已是最后一个',
                        icon: 'none'
                    });
                }
            }
        },
        
        // 换一批
        async changeBatch() {
            console.log('changeBatch方法被调用');
            // 检查order和task_id是否存在
            console.log('order:', this.order);
            console.log('task_id:', this.order.task_id);
            
            if (!this.order || !this.order.task_id) {
                console.error('order或task_id不存在，无法调用接口');
                uni.showToast({
                    title: '订单信息无效',
                    icon: 'none'
                });
                return;
            }
            
            uni.showLoading({
                title: '继续招募中...'
            });
            // 重置批次和页码
            this.currentBatch = 1;
            this.page = 1;
            console.log('准备调用fetchCandidates，page=' + this.page + ', batchSize=' + this.batchSize);
            
            try {
                // 保存当前索引
                const originalIndex = this.currentIndex;
                await this.fetchCandidates();
                console.log('fetchCandidates调用成功');
                // 不重置索引，保持在当前位置
            } catch (error) {
                console.error('fetchCandidates调用失败:', error);
                uni.showToast({
                    title: '获取候选人失败',
                    icon: 'none'
                });
            } finally {
                uni.hideLoading();
            }
        },
        
        // 选择当前候选人
        async selectTa() {
            try {
                // 切换选择状态
                const newSelected = !this.currentCandidate.selected;
                
                // 调用选择接口
                const response = await request({
                    url: '/WorkerPosts/selectCandidate',
                    method: 'POST',
                    data: {
                        candidate_id: this.currentCandidate.candidate_id,
                        job_id: this.order.task_id,
                        selected: newSelected
                    }
                });
                
                if (response.code === 200) {
                    // 更新本地状态
                    this.candidates[this.currentIndex].selected = newSelected;
                    this.selectedCount = this.candidates.filter(item => item.selected).length;
                    
                    uni.showToast({
                        title: newSelected ? '已选择' : '已取消选择',
                        icon: 'success'
                    });
                      
                    // 新增逻辑：当已选择人数等于待选择人数时关闭弹窗
                    if (this.selectedCount === this.selected_total) {
                        uni.showToast({
                            title: '已选满候选人',
                            icon: 'success',
                            duration: 1500
                        });
                        // 使用setTimeout确保toast显示完成后再跳转到首页
                        setTimeout(() => {
                            // 关闭弹窗
                            this.closeModal();
                            // 通知父组件招募已完成
                            this.$emit('recruitmentCompleted');
                            // 跳转到首页
                            uni.switchTab({
                                url: '/pages/index-new/index'
                            });
                        }, 1500);
                    }
                } else {
                    uni.showToast({
                        title: response.msg || '操作失败',
                        icon: 'none'
                    });
                }
            } catch (error) {
                console.error('选择候选人失败:', error);
                uni.showToast({
                    title: '网络错误，请重试',
                    icon: 'none'
                });
            }
        },
        
        // // 换一批
        // async changeBatch() {
        //     console.log('changeBatch方法被调用');
        //     // 检查order和task_id是否存在
        //     console.log('order:', this.order);
        //     console.log('task_id:', this.order.task_id);
            
        //     if (!this.order || !this.order.task_id) {
        //         console.error('order或task_id不存在，无法调用接口');
        //         uni.showToast({
        //             title: '订单信息无效',
        //             icon: 'none'
        //         });
        //         return;
        //     }
            
        //     uni.showLoading({
        //         title: '重新招募中...'
        //     });
        //     // 重置批次和页码
        //     this.currentBatch = 1;
        //     this.page = 1;
        //     console.log('准备调用fetchCandidates，page=' + this.page + ', batchSize=' + this.batchSize);
            
        //     try {
        //         await this.fetchCandidates();
        //         console.log('fetchCandidates调用成功');
        //         this.currentIndex = 0;
        //     } catch (error) {
        //         console.error('fetchCandidates调用失败:', error);
        //         uni.showToast({
        //             title: '获取候选人失败',
        //             icon: 'none'
        //         });
        //     } finally {
        //         uni.hideLoading();
        //     }
        // },
        
        // 开始倒计时
        startCountdown() {
            this.stopCountdown();
            this.updateRecruitmentDeadline();
            this.countdownTimer = setInterval(() => {
                this.updateCountdown();
            }, 1000);
        },
        
        // 停止倒计时
        stopCountdown() {
            if (this.countdownTimer) {
                clearInterval(this.countdownTimer);
                this.countdownTimer = null;
            }
        },
        
        // 更新招募截止时间
        async updateRecruitmentDeadline() {
            try {
                const response = await request({
                    url: '/Timer/checkRecruitmentDeadline',
                    method: 'GET',
                    data: {
                        job_id: this.order.task_id
                    }
                });
                
                if (response.code === 200 && response.data) {
                    this.recruitmentDeadline = new Date(response.data.deadline).getTime();
                    this.updateCountdown();
                }
            } catch (error) {
                console.error('获取招募截止时间失败:', error);
            }
        },
        
        // 更新倒计时显示
        updateCountdown() {
            if (!this.recruitmentDeadline) return;
            
            const now = new Date().getTime();
            const diff = this.recruitmentDeadline - now;
            
            if (diff <= 0) {
                this.countdownTime = '00:00';
                this.isRecruitmentExpired = true;
                this.stopCountdown();
                
                // 招募过期，自动关闭弹窗
                uni.showToast({
                    title: '招募时间已结束',
                    icon: 'none',
                    duration: 2000
                });
                
                setTimeout(() => {
                    this.closeModal();
                }, 2000);
                return;
            }
            
            const minutes = Math.floor(diff / (1000 * 60));
            const seconds = Math.floor((diff % (1000 * 60)) / 1000);
            
            this.countdownTime = `${minutes.toString().padStart(2, '0')}:${seconds.toString().padStart(2, '0')}`;
            this.isRecruitmentExpired = false;
        },
        
        // 取消任务
        async cancelTask() {
            // 显示确认弹窗
            uni.showModal({
                title: '确认取消任务',
                content: '确定要取消这个任务吗？',
                success: (res) => {
                    if (res.confirm) {
                        // 调用取消任务接口
                        this.cancelTaskApi();
                    }
                }
            });
        },
        
        // 调用取消任务接口
        async cancelTaskApi() {
            try {
                uni.showLoading({
                    title: '取消中...'
                });
                
                const response = await request({
                    url: '/WorkerPosts/cancelTask',
                    method: 'POST',
                    data: {
                        job_id: this.order.task_id
                    }
                });
                
                uni.hideLoading();
                
                if (response.code === 200) {
                    uni.showToast({
                        title: '任务已取消',
                        icon: 'success'
                    });
                    
                    // 关闭弹窗
                    this.closeModal();
                    
                    // 通知父组件刷新订单列表
                    this.$emit('taskCancelled');
                } else {
                    uni.showToast({
                        title: response.msg || '取消失败',
                        icon: 'none'
                    });
                }
            } catch (error) {
                uni.hideLoading();
                console.error('取消任务失败:', error);
                uni.showToast({
                    title: '网络错误，请重试',
                    icon: 'none'
                });
            }
        }
    }
}